{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gk6Gktxs5kLo"
      },
      "source": [
        "# Compiling Deepchem Torch Models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eBB_lWdA5kLp"
      },
      "source": [
        "Deep Learning models typically involve millions or even billions of parameters (as in the case of LLMs) that need to be fine-tuned through an iterative training processes. During training, these models process vast amounts of data  to learn patterns and features effectively. This data-intensive nature, combined with the computational complexity of operations like matrix multiplications and backpropagation, leads to lengthy training times that can span days, weeks, or even months on standard hardware. Additionally, the need for multiple training runs to experiment with the different model and hyperparameter configurations further extends the overall development time.\n",
        "\n",
        "Effective optimization techniques can significantly reduce training times, lower computational costs, and improve model performance. This makes optimization particularly crucial in research and industrial settings where faster iterations can accelerate scientific discoveries, product development, and the deployment of AI solutions. Moreover, as models grow larger and more sophisticated, optimization plays a vital role in making advanced AI accessible and practical for a wider range of applications and environments.\n",
        "\n",
        "To address the need for optimization of Deep Larning models and as an improvement over existing methods, PyTorch introduced the `torch.compile()` function in PyTorch 2.0 to allow faster training and inference of the models. `torch.compile()` works by compiling PyTorch code into optimised kernels using a JIT(Just in Time) compiler. Different models show varying levels of improvement in run times depending on their architecture and batch size when compiled. Compared to existing methods like [TorchScript](https://pytorch.org/docs/stable/jit.html) or [FX tracing](https://pytorch.org/docs/stable/fx.html), `compile()` also offers advantages such as the ability to handle arbitrary Python code and conditional graph-breaking flow of the inputs to the models. This allows `compile()` to work with minimal or no code modification to the model.\n",
        "\n",
        "DeepChem has builtin support for compiling PyTorch models using `torch.compile()` and using this feature, users can efficiently run PyTorch models and achieve significant performance gains. This tutorial contains the steps for compiling DeepChem PyTorch models, benchmarking and evaluating their performance with the uncompiled models.\n",
        "\n",
        ">NOTE: DeepChem contains many models with varying architecture and complexity. Not all models will show significant improvements in run times when compiled. It is recommended to test the models with and without compilation to determine the performance improvements."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-v09FDmPDDi"
      },
      "source": [
        "## Colab\n",
        "\n",
        "This tutorial and the rest in this sequence can be done in Google colab. If you'd like to open this notebook in colab, you can use the following link.\n",
        "\n",
        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/deepchem/deepchem/blob/master/examples/tutorials/Compiling_DeepChem_Torch_Models.ipynb)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3aJQJ3Qc5kLp"
      },
      "source": [
        "## Compilation Process\n",
        "\n",
        "This section gives an introductory explanation about the compilation process of PyTorch models and assumes prior knowledge about forward pass, backward pass and computational graphs in neural networks. If you're unfamiliar with these concepts, you can refer to these [slides](https://www.cs.cornell.edu/courses/cs5740/2017sp/lectures/04-nn-compgraph.pdf) for a basic understanding. Alternatively, you can proceed to the next section to learn how to compile and benchmark DeepChem models without delving into the internal details of the compilation process.\n",
        "\n",
        "\n",
        "![compilation-process](https://pytorch.org/assets/images/pytorch-2.0-img4.jpg)\n",
        "\n",
        "*Image taken from [PyTorch2.0 Introductory Blog](https://pytorch.org/get-started/pytorch-2.0/)*\n",
        "\n",
        "The compilation process is split into multiple steps which uses many new technologies that were introduced in PyTorch 2.0. The process is as follows:\n",
        "1. **Graph Acquisition:** During the compilation process, TorchDynamo and AOTAutograd are used for capturing the forward and backward pass graphs respectively. AOTAutograd allows the backward graph to be captured ahead of time without needing a backward pass to be performed.\n",
        "\n",
        "2. **Graph Lowering:** The captured graph that could be composed of the 2000+ PyTorch operators is lowered into a collection of ~250 Prim and ~750 ATen operators.\n",
        "\n",
        "3. **Graph Compilation:** In this step optimised low-level kernels are generated for the target accelerator using a suitable backend compiler. TorchInductor is the default backend compiler used for this purpose.\n",
        "\n",
        "Deepchem uses the `torch.compile()` function that implements all the above steps internally to compile the models. The compiled model can be used for training, evaluation and inference.\n",
        "\n",
        "For more information on the compilation process, refer to [PyTorch2.0 Introductory Blog](https://pytorch.org/get-started/pytorch-2.0/) that does a deep dive into the compilation process, technical decisions and future features for the compile function. You can also refer to the Huggingface blog, [Optimize inference using torch.compile()](https://huggingface.co/docs/transformers/main/en/perf_torch_compile) that benchmarks many common PyTorch models and shows the performance improvements when compiled."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hDfnQV3Y5kLp"
      },
      "source": [
        "## Compiling Models\n",
        "\n",
        "The compile function is only available in DeepChem for models that use PyTorch as the backend (i.e inherits `TorchModel` class). You can see the complete list of models that are available in DeepChem and their backends in the DeepChem Documentation [here](https://deepchem.readthedocs.io/en/latest/api_reference/models.html#model-cheatsheet).\n",
        "\n",
        "This tutorial contains the steps to load a DeepChem model, compile it and evaluate the performance improvements when compiled for both training and inference. Refer to the [documentation](https://deepchem.readthedocs.io/en/latest/api_reference/models.html#deepchem.models.TorchModel.compile) of DeepChem's compile function to read more about the different parameters you can pass to the function and their usage.\n",
        "\n",
        "If you just want to compile the model, you can add the line `model.compile()` after initialising the model. You **DO NOT** have to make any changes to the rest of your code.\n",
        "\n",
        "Some of the things to keep in mind when compiling models are:\n",
        "1. **Selecting the right mode:** The modes can be `default`, `reduce-overhead`, `max-autotune` or `max-autotune-no-cudagraphs`. Out of this `reduce-overhead` and `max-autotune` modes requires `triton` to be installed. Refer to the PyTorch [docs](https://pytorch.org/docs/stable/generated/torch.compile.html) on `torch.compile` for more information on the modes.\n",
        "\n",
        "2. **Setting `fullgraph` parameter:** If True (default `False`), `torch.compile` will require that the entire function be capturable into a single graph. If this is not possible (that is, if there are graph breaks), then the function will raise an error.\n",
        "\n",
        "3. **Experimenting with different parameter configuration:** Different parameter configurations can give different speedups based on the model, batch size and the device used for training/inference. Experiment with a few parameter combinations to check which one gives better results.\n",
        "\n",
        "In this tutorial, we will be using [DMPNN](https://deepchem.readthedocs.io/en/latest/api_reference/models.html#dmpnnmodel) model and [Freesolv Dataset](https://deepchem.readthedocs.io/en/latest/api_reference/moleculenet.html#freesolv-dataset) for training and inference of the models."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BVfF7rwx5kLp",
        "outputId": "dc2eb295-2258-42e4-efbf-911c2006ac1b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Collecting deepchem\n",
            "  Downloading deepchem-2.8.1.dev20240624214143-py3-none-any.whl (1.1 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: joblib in /usr/local/lib/python3.10/dist-packages (from deepchem) (1.4.2)\n",
            "Requirement already satisfied: numpy<2 in /usr/local/lib/python3.10/dist-packages (from deepchem) (1.25.2)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from deepchem) (2.0.3)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from deepchem) (1.2.2)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from deepchem) (1.12.1)\n",
            "Requirement already satisfied: scipy>=1.10.1 in /usr/local/lib/python3.10/dist-packages (from deepchem) (1.11.4)\n",
            "Collecting rdkit (from deepchem)\n",
            "  Downloading rdkit-2024.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (35.1 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m35.1/35.1 MB\u001b[0m \u001b[31m14.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->deepchem) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->deepchem) (2023.4)\n",
            "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas->deepchem) (2024.1)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.10/dist-packages (from rdkit->deepchem) (9.4.0)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->deepchem) (3.5.0)\n",
            "Requirement already satisfied: mpmath<1.4.0,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->deepchem) (1.3.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->deepchem) (1.16.0)\n",
            "Installing collected packages: rdkit, deepchem\n",
            "Successfully installed deepchem-2.8.1.dev20240624214143 rdkit-2024.3.1\n",
            "Collecting torch_geometric\n",
            "  Downloading torch_geometric-2.5.3-py3-none-any.whl (1.1 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m10.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (4.66.4)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (1.25.2)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (1.11.4)\n",
            "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (2023.6.0)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (3.1.4)\n",
            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (3.9.5)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (2.31.0)\n",
            "Requirement already satisfied: pyparsing in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (3.1.2)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (1.2.2)\n",
            "Requirement already satisfied: psutil>=5.8.0 in /usr/local/lib/python3.10/dist-packages (from torch_geometric) (5.9.5)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (1.3.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (23.2.0)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (1.4.1)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (6.0.5)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (1.9.4)\n",
            "Requirement already satisfied: async-timeout<5.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->torch_geometric) (4.0.3)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch_geometric) (2.1.5)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->torch_geometric) (2024.6.2)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->torch_geometric) (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->torch_geometric) (3.5.0)\n",
            "Installing collected packages: torch_geometric\n",
            "Successfully installed torch_geometric-2.5.3\n",
            "Requirement already satisfied: triton in /usr/local/lib/python3.10/dist-packages (2.3.0)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from triton) (3.15.3)\n"
          ]
        }
      ],
      "source": [
        "!pip install --pre deepchem\n",
        "!pip install torch_geometric #required for DMPNN model\n",
        "!pip install triton          #required for reduce-overhead mode"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f93stzpi5kLq",
        "outputId": "a4caed09-028c-4f8c-c721-9cd87a32c7a1"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:deepchem.feat.molecule_featurizers.rdkit_descriptors:No normalization for SPS. Feature removed!\n",
            "WARNING:deepchem.feat.molecule_featurizers.rdkit_descriptors:No normalization for AvgIpc. Feature removed!\n",
            "WARNING:tensorflow:From /usr/local/lib/python3.10/dist-packages/tensorflow/python/util/deprecation.py:588: calling function (from tensorflow.python.eager.polymorphic_function.polymorphic_function) with experimental_relax_shapes is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "experimental_relax_shapes is deprecated, use reduce_retracing instead\n",
            "WARNING:deepchem.models.torch_models:Skipped loading modules with pytorch-geometric dependency, missing a dependency. No module named 'dgl'\n",
            "WARNING:deepchem.models:Skipped loading modules with pytorch-lightning dependency, missing a dependency. No module named 'lightning'\n",
            "WARNING:deepchem.models:Skipped loading some Jax models, missing a dependency. No module named 'haiku'\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "\n",
        "import datetime\n",
        "import numpy as np\n",
        "import deepchem as dc\n",
        "\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6txSeCc65kLq"
      },
      "outputs": [],
      "source": [
        "torch._dynamo.config.cache_size_limit = 64"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t_ngfwLehwUZ"
      },
      "outputs": [],
      "source": [
        "tasks, datasets, transformers = dc.molnet.load_freesolv(featurizer=dc.feat.DMPNNFeaturizer(), splitter='random')\n",
        "train_dataset, valid_dataset, test_dataset = datasets\n",
        "len(train_dataset), len(valid_dataset), len(test_dataset)\n",
        "\n",
        "model = dc.models.DMPNNModel()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5JvrZEkS_G0O"
      },
      "source": [
        "The below line is the only addition you have to make to the code for compiling the model. You can pass in the other arguments too to the `compile()` function if they are required.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AWml7NB2_EwH",
        "outputId": "b014dea1-5ace-40d4-9401-2c5b57d86c9f"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/lib/python3.10/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
            "  self.pid = os.fork()\n"
          ]
        }
      ],
      "source": [
        "model.compile()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yUYI-_z7_DIn",
        "outputId": "dcb40cb9-535d-4129-8a8c-d33a4c640568"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training MSE: {'mean_squared_error': 0.04699941161198689}\n",
            "Validation MSE: {'mean_squared_error': 0.18010469643557037}\n",
            "Test MSE: {'mean_squared_error': 0.043559911545479245}\n"
          ]
        }
      ],
      "source": [
        "model.fit(train_dataset, nb_epoch=10)\n",
        "\n",
        "metrics = [dc.metrics.Metric(dc.metrics.mean_squared_error)]\n",
        "print(f\"Training MSE: {model.evaluate(train_dataset, metrics=metrics)}\")\n",
        "print(f\"Validation MSE: {model.evaluate(valid_dataset, metrics=metrics)}\")\n",
        "print(f\"Test MSE: {model.evaluate(test_dataset, metrics=metrics)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cC6O_ZaS5kLq"
      },
      "source": [
        "## Benchmarking model Speedups\n",
        "\n",
        "This section contains the steps for benchmarking the performance of models after compilation process for both training and inference. We are using the same model(DMPNN) and dataset(FreSolv) in this section too. The steps for compilation and benchmarking is same for other models as well.\n",
        "\n",
        "To account for the initial performance overhead of kernel compilation in compiled models, median values are employed as the performance metric throughout the tutorial for calculating speedup.\n",
        "\n",
        "The below two functions, `time_torch_function` and `get_time_track_callback` can be used for tracking the time taken for inference and training respectively.\n",
        "\n",
        "The implementation of `time_torch_function` is taken from the PyTorch official `torch.compile` tutorial [here](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html#demonstrating-speedups).\n",
        "\n",
        "We use `get_time_track_callback` to make a callback that can track the time taken for each batch during training as DeepChem does not provide a direct way to track the time taken per batch during training. We can use this callback by passing it as an argument to `model.fit()` function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_r7Z_e7F5kLr"
      },
      "outputs": [],
      "source": [
        "def time_torch_function(fn):\n",
        "    start = torch.cuda.Event(enable_timing=True)\n",
        "    end = torch.cuda.Event(enable_timing=True)\n",
        "    start.record()\n",
        "    result = fn()\n",
        "    end.record()\n",
        "    torch.cuda.synchronize()\n",
        "    return result, start.elapsed_time(end) / 1000\n",
        "\n",
        "track_dict = {}\n",
        "prev_time_dict = {}\n",
        "\n",
        "def get_time_track_callback(track_dict, track_name, track_interval):\n",
        "    track_dict[track_name] = []\n",
        "    prev_time_dict[track_name] = datetime.datetime.now()\n",
        "    def callback(model, step):\n",
        "        if step % track_interval == 0:\n",
        "            elapsed_time = datetime.datetime.now() - prev_time_dict[track_name]\n",
        "            track_dict[track_name].append(elapsed_time.total_seconds())\n",
        "            prev_time_dict[track_name] = datetime.datetime.now()\n",
        "    return callback"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2PLiQcL_5kLr"
      },
      "source": [
        "### Tracking Training Time"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vGFUxgGF5kLr",
        "outputId": "496e9603-fe94-4e24-9b50-c13081248908"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.06506308714548746"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model = dc.models.DMPNNModel()\n",
        "model_compiled = dc.models.DMPNNModel()\n",
        "model_compiled.compile(mode='reduce-overhead')\n",
        "\n",
        "track_interval = 20\n",
        "eager_dict_name = \"eager_train\"\n",
        "compiled_dict_name = \"compiled_train\"\n",
        "\n",
        "eager_train_callback = get_time_track_callback(track_dict, eager_dict_name, track_interval)\n",
        "model.fit(train_dataset, nb_epoch=10, callbacks=[eager_train_callback])\n",
        "\n",
        "compiled_train_callback = get_time_track_callback(track_dict, compiled_dict_name, track_interval)\n",
        "model_compiled.fit(train_dataset, nb_epoch=10, callbacks=[compiled_train_callback])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Ldo5kiR5kLr",
        "outputId": "ce1b716c-3967-4cbb-b99d-42cf199426e2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eager Times (first 15): ['1.067', '0.112', '0.093', '0.097', '0.102', '0.098', '0.095', '0.097', '0.099', '0.098', '0.097', '0.103', '0.095', '0.103', '0.096']\n",
            "Compiled Times (first 15): ['29.184', '21.463', '11.503', '13.742', '1.951', '5.595', '7.568', '8.201', '7.761', '0.083', '7.087', '2.421', '1.961', '0.079', '1.948']\n",
            "Total Eager Time: 29.176121000000023\n",
            "Total Compiled Time: 243.32460400000022\n",
            "Eager Median: 0.100118\n",
            "Compiled Median: 0.0843535\n",
            "Median Speedup: 18.69%\n"
          ]
        }
      ],
      "source": [
        "eager_train_times = track_dict[eager_dict_name]\n",
        "compiled_train_times = track_dict[compiled_dict_name]\n",
        "\n",
        "print(f\"Eager Times (first 15): {[f'{t:.3f}' for t in eager_train_times[:15]]}\")\n",
        "print(f\"Compiled Times (first 15): {[f'{t:.3f}' for t in compiled_train_times[:15]]}\")\n",
        "print(f\"Total Eager Time: {sum(eager_train_times)}\")\n",
        "print(f\"Total Compiled Time: {sum(compiled_train_times)}\")\n",
        "print(f\"Eager Median: {np.median(eager_train_times)}\")\n",
        "print(f\"Compiled Median: {np.median(compiled_train_times)}\")\n",
        "print(f\"Median Speedup: {((np.median(eager_train_times) / np.median(compiled_train_times)) - 1) * 100:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "id": "_OGSk4SS5kLr",
        "outputId": "32fc8ab6-cded-4249-e492-5f24ebea3cd6"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "x_vals = np.arange(1, len(eager_train_times) + 1) * track_interval\n",
        "plt.plot(x_vals, eager_train_times, label=\"Eager\")\n",
        "plt.plot(x_vals, compiled_train_times, label=\"Compiled\")\n",
        "plt.yscale('log', base= 10)\n",
        "plt.ylabel('Time (s)')\n",
        "plt.xlabel('Batch Iteration')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JiZmYdt45kLr"
      },
      "source": [
        "Looking at the graph, there is a significant difference in the time taken for the compiled and uncompiled versions of the model for the starting many steps. After that the time taken by the compiled model stabilises below the uncompiled model. This is because the compilation is done JIT when the model is first run and the optimized kernels are generated after a few passes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l6Lowwrl5kLr"
      },
      "source": [
        "### Tracking Inference Time"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SvrkTBQm5kLr"
      },
      "outputs": [],
      "source": [
        "model = dc.models.DMPNNModel()\n",
        "model_compiled = dc.models.DMPNNModel()\n",
        "model_compiled.compile(mode='reduce-overhead')\n",
        "\n",
        "iters = 100\n",
        "\n",
        "eager_predict_times = []\n",
        "compiled_predict_times = []\n",
        "\n",
        "for i in range(iters):\n",
        "    for X, y, w, ids in test_dataset.iterbatches(64, pad_batches=True):\n",
        "        with torch.no_grad():\n",
        "            _, eager_time = time_torch_function(lambda: model.predict_on_batch(X))\n",
        "            _, compiled_time = time_torch_function(lambda: model_compiled.predict_on_batch(X))\n",
        "\n",
        "        eager_predict_times.append(eager_time)\n",
        "        compiled_predict_times.append(compiled_time)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ikXK8vE5kLr",
        "outputId": "9b044210-fd70-4c36-8d92-52aad3e2f8da"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Eager Times (first 15): ['0.170', '0.173', '0.161', '0.160', '0.160', '0.165', '0.158', '0.159', '0.164', '0.161', '0.162', '0.154', '0.159', '0.161', '0.162']\n",
            "Compiled Times (first 15): ['47.617', '1.168', '26.927', '0.127', '0.134', '0.138', '0.130', '0.130', '0.133', '0.125', '0.130', '0.132', '0.139', '0.128', '0.133']\n",
            "Total Eager Time: 35.297711242675796\n",
            "Total Compiled Time: 104.20891365814221\n",
            "Eager Median: 0.1617226104736328\n",
            "Compiled Median: 0.1332385482788086\n",
            "Median Speedup: 21.38%\n"
          ]
        }
      ],
      "source": [
        "print(f\"Eager Times (first 15): {[f'{t:.3f}' for t in eager_predict_times[:15]]}\")\n",
        "print(f\"Compiled Times (first 15): {[f'{t:.3f}' for t in compiled_predict_times[:15]]}\")\n",
        "print(f\"Total Eager Time: {sum(eager_predict_times)}\")\n",
        "print(f\"Total Compiled Time: {sum(compiled_predict_times)}\")\n",
        "print(f\"Eager Median: {np.median(eager_predict_times)}\")\n",
        "print(f\"Compiled Median: {np.median(compiled_predict_times)}\")\n",
        "print(f\"Median Speedup: {((np.median(eager_predict_times) / np.median(compiled_predict_times)) - 1) * 100:.2f}%\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 466
        },
        "id": "e6H_XLwQ5kLs",
        "outputId": "da29e4f4-6ef7-4295-9e03-ff096f2b6986"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7c7a040c9c30>"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.plot(eager_predict_times, label= \"Eager\")\n",
        "plt.plot(compiled_predict_times, label= \"Compiled\")\n",
        "plt.ylabel('Time (s)')\n",
        "plt.xlabel('Batch Iteration')\n",
        "plt.yscale('log', base= 10)\n",
        "plt.legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p0aEj_KlCJfS"
      },
      "source": [
        "As with the results we got training, the first few runs for inference also takes significantly more time due to the same reason as mentioned before."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UA-FIXx3M373"
      },
      "source": [
        "# Congratulations! Time to join the Community!\n",
        "Congratulations on completing this tutorial notebook! If you enjoyed working through the tutorial, and want to continue working with DeepChem, we encourage you to finish the rest of the tutorials in this series. You can also help the DeepChem community in the following ways:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0J0uGE4M6u-"
      },
      "source": [
        "## Star DeepChem on [GitHub](https://github.com/deepchem/deepchem)\n",
        "This helps build awareness of the DeepChem project and the tools for open source drug discovery that we're trying to build.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g0JnpFMWNB0f"
      },
      "source": [
        "## Join the DeepChem Discord\n",
        "The DeepChem [Discord](https://discord.gg/cGzwCdrUqS) hosts a number of scientists, developers, and enthusiasts interested in deep learning for the life sciences. Join the conversation!"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.18"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
